home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / misc / fcxref.lha / FCXRef / Src / lex.yy.c < prev    next >
C/C++ Source or Header  |  1999-01-31  |  37KB  |  1,548 lines
  1. /* A lexical scanner generated by flex */
  2.  
  3. /* Scanner skeleton version:
  4.  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
  5.  */
  6.  
  7. #define FLEX_SCANNER
  8. #define YY_FLEX_MAJOR_VERSION 2
  9. #define YY_FLEX_MINOR_VERSION 5
  10.  
  11. #include <stdio.h>
  12.  
  13.  
  14. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15. #ifdef c_plusplus
  16. #ifndef __cplusplus
  17. #define __cplusplus
  18. #endif
  19. #endif
  20.  
  21.  
  22. #ifdef __cplusplus
  23.  
  24. #include <stdlib.h>
  25. #include <unistd.h>
  26.  
  27. /* Use prototypes in function declarations. */
  28. #define YY_USE_PROTOS
  29.  
  30. /* The "const" storage-class-modifier is valid. */
  31. #define YY_USE_CONST
  32.  
  33. #else    /* ! __cplusplus */
  34.  
  35. #if __STDC__
  36.  
  37. #define YY_USE_PROTOS
  38. #define YY_USE_CONST
  39.  
  40. #endif    /* __STDC__ */
  41. #endif    /* ! __cplusplus */
  42.  
  43. #ifdef __TURBOC__
  44.  #pragma warn -rch
  45.  #pragma warn -use
  46. #include <io.h>
  47. #include <stdlib.h>
  48. #define YY_USE_CONST
  49. #define YY_USE_PROTOS
  50. #endif
  51.  
  52. #ifdef YY_USE_CONST
  53. #define yyconst const
  54. #else
  55. #define yyconst
  56. #endif
  57.  
  58.  
  59. #ifdef YY_USE_PROTOS
  60. #define YY_PROTO(proto) proto
  61. #else
  62. #define YY_PROTO(proto) ()
  63. #endif
  64.  
  65. /* Returned upon end-of-file. */
  66. #define YY_NULL 0
  67.  
  68. /* Promotes a possibly negative, possibly signed char to an unsigned
  69.  * integer for use as an array index.  If the signed char is negative,
  70.  * we want to instead treat it as an 8-bit unsigned char, hence the
  71.  * double cast.
  72.  */
  73. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  74.  
  75. /* Enter a start condition.  This macro really ought to take a parameter,
  76.  * but we do it the disgusting crufty way forced on us by the ()-less
  77.  * definition of BEGIN.
  78.  */
  79. #define BEGIN yy_start = 1 + 2 *
  80.  
  81. /* Translate the current start state into a value that can be later handed
  82.  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83.  * compatibility.
  84.  */
  85. #define YY_START ((yy_start - 1) / 2)
  86. #define YYSTATE YY_START
  87.  
  88. /* Action number for EOF rule of a given start state. */
  89. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  90.  
  91. /* Special action meaning "start processing a new file". */
  92. #define YY_NEW_FILE yyrestart( yyin )
  93.  
  94. #define YY_END_OF_BUFFER_CHAR 0
  95.  
  96. /* Size of default input buffer. */
  97. #define YY_BUF_SIZE 16384
  98.  
  99. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  100.  
  101. extern int yyleng;
  102. extern FILE *yyin, *yyout;
  103.  
  104. #define EOB_ACT_CONTINUE_SCAN 0
  105. #define EOB_ACT_END_OF_FILE 1
  106. #define EOB_ACT_LAST_MATCH 2
  107.  
  108. /* The funky do-while in the following #define is used to turn the definition
  109.  * int a single C statement (which needs a semi-colon terminator).  This
  110.  * avoids problems with code like:
  111.  *
  112.  *     if ( condition_holds )
  113.  *        yyless( 5 );
  114.  *    else
  115.  *        do_something_else();
  116.  *
  117.  * Prior to using the do-while the compiler would get upset at the
  118.  * "else" because it interpreted the "if" statement as being all
  119.  * done when it reached the ';' after the yyless() call.
  120.  */
  121.  
  122. /* Return all but the first 'n' matched characters back to the input stream. */
  123.  
  124. #define yyless(n) \
  125.     do \
  126.         { \
  127.         /* Undo effects of setting up yytext. */ \
  128.         *yy_cp = yy_hold_char; \
  129.         YY_RESTORE_YY_MORE_OFFSET \
  130.         yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
  131.         YY_DO_BEFORE_ACTION; /* set up yytext again */ \
  132.         } \
  133.     while ( 0 )
  134.  
  135. #define unput(c) yyunput( c, yytext_ptr )
  136.  
  137. /* The following is because we cannot portably get our hands on size_t
  138.  * (without autoconf's help, which isn't available because we want
  139.  * flex-generated scanners to compile on their own).
  140.  */
  141. typedef unsigned int yy_size_t;
  142.  
  143.  
  144. struct yy_buffer_state
  145.     {
  146.     FILE *yy_input_file;
  147.  
  148.     char *yy_ch_buf;        /* input buffer */
  149.     char *yy_buf_pos;        /* current position in input buffer */
  150.  
  151.     /* Size of input buffer in bytes, not including room for EOB
  152.      * characters.
  153.      */
  154.     yy_size_t yy_buf_size;
  155.  
  156.     /* Number of characters read into yy_ch_buf, not including EOB
  157.      * characters.
  158.      */
  159.     int yy_n_chars;
  160.  
  161.     /* Whether we "own" the buffer - i.e., we know we created it,
  162.      * and can realloc() it to grow it, and should free() it to
  163.      * delete it.
  164.      */
  165.     int yy_is_our_buffer;
  166.  
  167.     /* Whether this is an "interactive" input source; if so, and
  168.      * if we're using stdio for input, then we want to use getc()
  169.      * instead of fread(), to make sure we stop fetching input after
  170.      * each newline.
  171.      */
  172.     int yy_is_interactive;
  173.  
  174.     /* Whether we're considered to be at the beginning of a line.
  175.      * If so, '^' rules will be active on the next match, otherwise
  176.      * not.
  177.      */
  178.     int yy_at_bol;
  179.  
  180.     /* Whether to try to fill the input buffer when we reach the
  181.      * end of it.
  182.      */
  183.     int yy_fill_buffer;
  184.  
  185.     int yy_buffer_status;
  186. #define YY_BUFFER_NEW 0
  187. #define YY_BUFFER_NORMAL 1
  188.     /* When an EOF's been seen but there's still some text to process
  189.      * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  190.      * shouldn't try reading from the input source any more.  We might
  191.      * still have a bunch of tokens to match, though, because of
  192.      * possible backing-up.
  193.      *
  194.      * When we actually see the EOF, we change the status to "new"
  195.      * (via yyrestart()), so that the user can continue scanning by
  196.      * just pointing yyin at a new input file.
  197.      */
  198. #define YY_BUFFER_EOF_PENDING 2
  199.     };
  200.  
  201. static YY_BUFFER_STATE yy_current_buffer = 0;
  202.  
  203. /* We provide macros for accessing buffer states in case in the
  204.  * future we want to put the buffer states in a more general
  205.  * "scanner state".
  206.  */
  207. #define YY_CURRENT_BUFFER yy_current_buffer
  208.  
  209.  
  210. /* yy_hold_char holds the character lost when yytext is formed. */
  211. static char yy_hold_char;
  212.  
  213. static int yy_n_chars;        /* number of characters read into yy_ch_buf */
  214.  
  215.  
  216. int yyleng;
  217.  
  218. /* Points to current character in buffer. */
  219. static char *yy_c_buf_p = (char *) 0;
  220. static int yy_init = 1;        /* whether we need to initialize */
  221. static int yy_start = 0;    /* start state number */
  222.  
  223. /* Flag which is used to allow yywrap()'s to do buffer switches
  224.  * instead of setting up a fresh yyin.  A bit of a hack ...
  225.  */
  226. static int yy_did_buffer_switch_on_eof;
  227.  
  228. void yyrestart YY_PROTO(( FILE *input_file ));
  229.  
  230. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  231. void yy_load_buffer_state YY_PROTO(( void ));
  232. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  233. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  234. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  235. void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  236. #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
  237.  
  238. YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
  239. YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
  240. YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
  241.  
  242. static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
  243. static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
  244. static void yy_flex_free YY_PROTO(( void * ));
  245.  
  246. #define yy_new_buffer yy_create_buffer
  247.  
  248. #define yy_set_interactive(is_interactive) \
  249.     { \
  250.     if ( ! yy_current_buffer ) \
  251.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  252.     yy_current_buffer->yy_is_interactive = is_interactive; \
  253.     }
  254.  
  255. #define yy_set_bol(at_bol) \
  256.     { \
  257.     if ( ! yy_current_buffer ) \
  258.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
  259.     yy_current_buffer->yy_at_bol = at_bol; \
  260.     }
  261.  
  262. #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
  263.  
  264. typedef unsigned char YY_CHAR;
  265. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  266. typedef int yy_state_type;
  267. extern char *yytext;
  268. #define yytext_ptr yytext
  269.  
  270. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  271. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  272. static int yy_get_next_buffer YY_PROTO(( void ));
  273. static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
  274.  
  275. /* Done after the current pattern has been matched and before the
  276.  * corresponding action - sets up yytext.
  277.  */
  278. #define YY_DO_BEFORE_ACTION \
  279.     yytext_ptr = yy_bp; \
  280.     yyleng = (int) (yy_cp - yy_bp); \
  281.     yy_hold_char = *yy_cp; \
  282.     *yy_cp = '\0'; \
  283.     yy_c_buf_p = yy_cp;
  284.  
  285. #define YY_NUM_RULES 5
  286. #define YY_END_OF_BUFFER 6
  287. static yyconst short int yy_accept[20] =
  288.     {   0,
  289.         0,    0,    2,    2,    6,    4,    3,    4,    5,    2,
  290.         0,    0,    2,    0,    0,    0,    0,    1,    0
  291.     } ;
  292.  
  293. static yyconst int yy_ec[256] =
  294.     {   0,
  295.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  296.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  297.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  298.         1,    2,    1,    2,    4,    1,    1,    1,    1,    1,
  299.         1,    1,    1,    1,    1,    1,    1,    5,    5,    5,
  300.         5,    5,    5,    5,    5,    5,    5,    1,    1,    1,
  301.         1,    1,    1,    1,    5,    5,    5,    5,    5,    5,
  302.         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
  303.         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
  304.         1,    1,    1,    1,    1,    1,    5,    5,    5,    6,
  305.  
  306.         7,    8,    5,    5,    9,    5,    5,    5,    5,   10,
  307.         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
  308.         5,    5,    1,    1,    1,    1,    1,    1,    1,    1,
  309.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  310.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  311.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  312.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  313.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  314.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  315.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  316.  
  317.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  318.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  319.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  320.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  321.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  322.         1,    1,    1,    1,    1
  323.     } ;
  324.  
  325. static yyconst int yy_meta[11] =
  326.     {   0,
  327.         1,    1,    1,    1,    2,    2,    2,    2,    2,    2
  328.     } ;
  329.  
  330. static yyconst short int yy_base[23] =
  331.     {   0,
  332.         0,    2,    6,   10,   26,   27,   27,   13,   27,    0,
  333.         0,   18,    0,   16,    9,    7,    9,   27,   27,   19,
  334.        21,    0
  335.     } ;
  336.  
  337. static yyconst short int yy_def[23] =
  338.     {   0,
  339.        20,   20,   21,   21,   19,   19,   19,   19,   19,   22,
  340.         8,   19,   22,   19,   19,   19,   19,   19,    0,   19,
  341.        19,   19
  342.     } ;
  343.  
  344. static yyconst short int yy_nxt[38] =
  345.     {   0,
  346.        19,   13,    7,    8,    7,    8,    9,    9,    9,    9,
  347.         9,    9,    9,    9,   11,   18,   17,   16,   12,    6,
  348.         6,   10,   10,   15,   14,   19,    5,   19,   19,   19,
  349.        19,   19,   19,   19,   19,   19,   19
  350.     } ;
  351.  
  352. static yyconst short int yy_chk[38] =
  353.     {   0,
  354.         0,   22,    1,    1,    2,    2,    3,    3,    3,    3,
  355.         4,    4,    4,    4,    8,   17,   16,   15,    8,   20,
  356.        20,   21,   21,   14,   12,    5,   19,   19,   19,   19,
  357.        19,   19,   19,   19,   19,   19,   19
  358.     } ;
  359.  
  360. static yy_state_type yy_last_accepting_state;
  361. static char *yy_last_accepting_cpos;
  362.  
  363. /* The intent behind this definition is that it'll catch
  364.  * any uses of REJECT which flex missed.
  365.  */
  366. #define REJECT reject_used_but_not_detected
  367. #define yymore() yymore_used_but_not_detected
  368. #define YY_MORE_ADJ 0
  369. #define YY_RESTORE_YY_MORE_OFFSET
  370. char *yytext;
  371. #line 1 "head.l"
  372. #define INITIAL 0
  373. #line 2 "head.l"
  374. #include <stdio.h>
  375. #include <stdlib.h>
  376.  
  377. extern int AddFunc(char *file, char *func,int linenum);
  378.  
  379. int lineno;
  380.  
  381. #define xdefine 1
  382.  
  383. #line 384 "lex.yy.c"
  384.  
  385. /* Macros after this point can all be overridden by user definitions in
  386.  * section 1.
  387.  */
  388.  
  389. #ifndef YY_SKIP_YYWRAP
  390. #ifdef __cplusplus
  391. extern "C" int yywrap YY_PROTO(( void ));
  392. #else
  393. extern int yywrap YY_PROTO(( void ));
  394. #endif
  395. #endif
  396.  
  397. #ifndef YY_NO_UNPUT
  398. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  399. #endif
  400.  
  401. #ifndef yytext_ptr
  402. static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
  403. #endif
  404.  
  405. #ifdef YY_NEED_STRLEN
  406. static int yy_flex_strlen YY_PROTO(( yyconst char * ));
  407. #endif
  408.  
  409. #ifndef YY_NO_INPUT
  410. #ifdef __cplusplus
  411. static int yyinput YY_PROTO(( void ));
  412. #else
  413. static int input YY_PROTO(( void ));
  414. #endif
  415. #endif
  416.  
  417. #if YY_STACK_USED
  418. static int yy_start_stack_ptr = 0;
  419. static int yy_start_stack_depth = 0;
  420. static int *yy_start_stack = 0;
  421. #ifndef YY_NO_PUSH_STATE
  422. static void yy_push_state YY_PROTO(( int new_state ));
  423. #endif
  424. #ifndef YY_NO_POP_STATE
  425. static void yy_pop_state YY_PROTO(( void ));
  426. #endif
  427. #ifndef YY_NO_TOP_STATE
  428. static int yy_top_state YY_PROTO(( void ));
  429. #endif
  430.  
  431. #else
  432. #define YY_NO_PUSH_STATE 1
  433. #define YY_NO_POP_STATE 1
  434. #define YY_NO_TOP_STATE 1
  435. #endif
  436.  
  437. #ifdef YY_MALLOC_DECL
  438. YY_MALLOC_DECL
  439. #else
  440. #if __STDC__
  441. #ifndef __cplusplus
  442. #include <stdlib.h>
  443. #endif
  444. #else
  445. /* Just try to get by without declaring the routines.  This will fail
  446.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  447.  * or sizeof(void*) != sizeof(int).
  448.  */
  449. #endif
  450. #endif
  451.  
  452. /* Amount of stuff to slurp up with each read. */
  453. #ifndef YY_READ_BUF_SIZE
  454. #define YY_READ_BUF_SIZE 8192
  455. #endif
  456.  
  457. /* Copy whatever the last rule matched to the standard output. */
  458.  
  459. #ifndef ECHO
  460. /* This used to be an fputs(), but since the string might contain NUL's,
  461.  * we now use fwrite().
  462.  */
  463. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  464. #endif
  465.  
  466. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  467.  * is returned in "result".
  468.  */
  469. #ifndef YY_INPUT
  470. #define YY_INPUT(buf,result,max_size) \
  471.     if ( yy_current_buffer->yy_is_interactive ) \
  472.         { \
  473.         int c = '*', n; \
  474.         for ( n = 0; n < max_size && \
  475.                  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
  476.             buf[n] = (char) c; \
  477.         if ( c == '\n' ) \
  478.             buf[n++] = (char) c; \
  479.         if ( c == EOF && ferror( yyin ) ) \
  480.             YY_FATAL_ERROR( "input in flex scanner failed" ); \
  481.         result = n; \
  482.         } \
  483.     else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
  484.           && ferror( yyin ) ) \
  485.         YY_FATAL_ERROR( "input in flex scanner failed" );
  486. #endif
  487.  
  488. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  489.  * we don't want an extra ';' after the "return" because that will cause
  490.  * some compilers to complain about unreachable statements.
  491.  */
  492. #ifndef yyterminate
  493. #define yyterminate() return YY_NULL
  494. #endif
  495.  
  496. /* Number of entries by which start-condition stack grows. */
  497. #ifndef YY_START_STACK_INCR
  498. #define YY_START_STACK_INCR 25
  499. #endif
  500.  
  501. /* Report a fatal error. */
  502. #ifndef YY_FATAL_ERROR
  503. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  504. #endif
  505.  
  506. /* Default declaration of generated scanner - a define so the user can
  507.  * easily add parameters.
  508.  */
  509. #ifndef YY_DECL
  510. #define YY_DECL int yylex YY_PROTO(( void ))
  511. #endif
  512.  
  513. /* Code executed at the beginning of each rule, after yytext and yyleng
  514.  * have been set up.
  515.  */
  516. #ifndef YY_USER_ACTION
  517. #define YY_USER_ACTION
  518. #endif
  519.  
  520. /* Code executed at the end of each rule. */
  521. #ifndef YY_BREAK
  522. #define YY_BREAK break;
  523. #endif
  524.  
  525. #define YY_RULE_SETUP \
  526.     YY_USER_ACTION
  527.  
  528. YY_DECL
  529.     {
  530.     register yy_state_type yy_current_state;
  531.     register char *yy_cp, *yy_bp;
  532.     register int yy_act;
  533.  
  534. #line 13 "head.l"
  535.  
  536.  
  537. #line 538 "lex.yy.c"
  538.  
  539.     if ( yy_init )
  540.         {
  541.         yy_init = 0;
  542.  
  543. #ifdef YY_USER_INIT
  544.         YY_USER_INIT;
  545. #endif
  546.  
  547.         if ( ! yy_start )
  548.             yy_start = 1;    /* first start state */
  549.  
  550.         if ( ! yyin )
  551.             yyin = stdin;
  552.  
  553.         if ( ! yyout )
  554.             yyout = stdout;
  555.  
  556.         if ( ! yy_current_buffer )
  557.             yy_current_buffer =
  558.                 yy_create_buffer( yyin, YY_BUF_SIZE );
  559.  
  560.         yy_load_buffer_state();
  561.         }
  562.  
  563.     while ( 1 )        /* loops until end-of-file is reached */
  564.         {
  565.         yy_cp = yy_c_buf_p;
  566.  
  567.         /* Support of yytext. */
  568.         *yy_cp = yy_hold_char;
  569.  
  570.         /* yy_bp points to the position in yy_ch_buf of the start of
  571.          * the current run.
  572.          */
  573.         yy_bp = yy_cp;
  574.  
  575.         yy_current_state = yy_start;
  576. yy_match:
  577.         do
  578.             {
  579.             register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  580.             if ( yy_accept[yy_current_state] )
  581.                 {
  582.                 yy_last_accepting_state = yy_current_state;
  583.                 yy_last_accepting_cpos = yy_cp;
  584.                 }
  585.             while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  586.                 {
  587.                 yy_current_state = (int) yy_def[yy_current_state];
  588.                 if ( yy_current_state >= 20 )
  589.                     yy_c = yy_meta[(unsigned int) yy_c];
  590.                 }
  591.             yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  592.             ++yy_cp;
  593.             }
  594.         while ( yy_base[yy_current_state] != 27 );
  595.  
  596. yy_find_action:
  597.         yy_act = yy_accept[yy_current_state];
  598.         if ( yy_act == 0 )
  599.             { /* have to back up */
  600.             yy_cp = yy_last_accepting_cpos;
  601.             yy_current_state = yy_last_accepting_state;
  602.             yy_act = yy_accept[yy_current_state];
  603.             }
  604.  
  605.         YY_DO_BEFORE_ACTION;
  606.  
  607.  
  608. do_action:    /* This label is used only to access EOF actions. */
  609.  
  610.  
  611.         switch ( yy_act )
  612.     { /* beginning of action switch */
  613.             case 0: /* must back up */
  614.             /* undo the effects of YY_DO_BEFORE_ACTION */
  615.             *yy_cp = yy_hold_char;
  616.             yy_cp = yy_last_accepting_cpos;
  617.             yy_current_state = yy_last_accepting_state;
  618.             goto yy_find_action;
  619.  
  620. case 1:
  621. YY_RULE_SETUP
  622. #line 15 "head.l"
  623. { BEGIN(xdefine); }
  624.     YY_BREAK
  625. case 2:
  626. YY_RULE_SETUP
  627. #line 17 "head.l"
  628. {
  629.                         AddFunc(actfile,yytext,lineno);
  630.                         BEGIN(INITIAL);
  631.                         }
  632.     YY_BREAK
  633. case 3:
  634. YY_RULE_SETUP
  635. #line 22 "head.l"
  636. { ++lineno; }
  637.     YY_BREAK
  638. case 4:
  639. YY_RULE_SETUP
  640. #line 24 "head.l"
  641.  
  642.     YY_BREAK
  643. case 5:
  644. YY_RULE_SETUP
  645. #line 26 "head.l"
  646. ECHO;
  647.     YY_BREAK
  648. #line 649 "lex.yy.c"
  649. case YY_STATE_EOF(INITIAL):
  650. case YY_STATE_EOF(xdefine):
  651.     yyterminate();
  652.  
  653.     case YY_END_OF_BUFFER:
  654.         {
  655.         /* Amount of text matched not including the EOB char. */
  656.         int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
  657.  
  658.         /* Undo the effects of YY_DO_BEFORE_ACTION. */
  659.         *yy_cp = yy_hold_char;
  660.         YY_RESTORE_YY_MORE_OFFSET
  661.  
  662.         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  663.             {
  664.             /* We're scanning a new file or input source.  It's
  665.              * possible that this happened because the user
  666.              * just pointed yyin at a new source and called
  667.              * yylex().  If so, then we have to assure
  668.              * consistency between yy_current_buffer and our
  669.              * globals.  Here is the right place to do so, because
  670.              * this is the first action (other than possibly a
  671.              * back-up) that will match for the new input source.
  672.              */
  673.             yy_n_chars = yy_current_buffer->yy_n_chars;
  674.             yy_current_buffer->yy_input_file = yyin;
  675.             yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  676.             }
  677.  
  678.         /* Note that here we test for yy_c_buf_p "<=" to the position
  679.          * of the first EOB in the buffer, since yy_c_buf_p will
  680.          * already have been incremented past the NUL character
  681.          * (since all states make transitions on EOB to the
  682.          * end-of-buffer state).  Contrast this with the test
  683.          * in input().
  684.          */
  685.         if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  686.             { /* This was really a NUL. */
  687.             yy_state_type yy_next_state;
  688.  
  689.             yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  690.  
  691.             yy_current_state = yy_get_previous_state();
  692.  
  693.             /* Okay, we're now positioned to make the NUL
  694.              * transition.  We couldn't have
  695.              * yy_get_previous_state() go ahead and do it
  696.              * for us because it doesn't know how to deal
  697.              * with the possibility of jamming (and we don't
  698.              * want to build jamming into it because then it
  699.              * will run more slowly).
  700.              */
  701.  
  702.             yy_next_state = yy_try_NUL_trans( yy_current_state );
  703.  
  704.             yy_bp = yytext_ptr + YY_MORE_ADJ;
  705.  
  706.             if ( yy_next_state )
  707.                 {
  708.                 /* Consume the NUL. */
  709.                 yy_cp = ++yy_c_buf_p;
  710.                 yy_current_state = yy_next_state;
  711.                 goto yy_match;
  712.                 }
  713.  
  714.             else
  715.                 {
  716.                 yy_cp = yy_c_buf_p;
  717.                 goto yy_find_action;
  718.                 }
  719.             }
  720.  
  721.         else switch ( yy_get_next_buffer() )
  722.             {
  723.             case EOB_ACT_END_OF_FILE:
  724.                 {
  725.                 yy_did_buffer_switch_on_eof = 0;
  726.  
  727.                 if ( yywrap() )
  728.                     {
  729.                     /* Note: because we've taken care in
  730.                      * yy_get_next_buffer() to have set up
  731.                      * yytext, we can now set up
  732.                      * yy_c_buf_p so that if some total
  733.                      * hoser (like flex itself) wants to
  734.                      * call the scanner after we return the
  735.                      * YY_NULL, it'll still work - another
  736.                      * YY_NULL will get returned.
  737.                      */
  738.                     yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  739.  
  740.                     yy_act = YY_STATE_EOF(YY_START);
  741.                     goto do_action;
  742.                     }
  743.  
  744.                 else
  745.                     {
  746.                     if ( ! yy_did_buffer_switch_on_eof )
  747.                         YY_NEW_FILE;
  748.                     }
  749.                 break;
  750.                 }
  751.  
  752.             case EOB_ACT_CONTINUE_SCAN:
  753.                 yy_c_buf_p =
  754.                     yytext_ptr + yy_amount_of_matched_text;
  755.  
  756.                 yy_current_state = yy_get_previous_state();
  757.  
  758.                 yy_cp = yy_c_buf_p;
  759.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  760.                 goto yy_match;
  761.  
  762.             case EOB_ACT_LAST_MATCH:
  763.                 yy_c_buf_p =
  764.                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
  765.  
  766.                 yy_current_state = yy_get_previous_state();
  767.  
  768.                 yy_cp = yy_c_buf_p;
  769.                 yy_bp = yytext_ptr + YY_MORE_ADJ;
  770.                 goto yy_find_action;
  771.             }
  772.         break;
  773.         }
  774.  
  775.     default:
  776.         YY_FATAL_ERROR(
  777.             "fatal flex scanner internal error--no action found" );
  778.     } /* end of action switch */
  779.         } /* end of scanning one token */
  780.     } /* end of yylex */
  781.  
  782.  
  783. /* yy_get_next_buffer - try to read in a new buffer
  784.  *
  785.  * Returns a code representing an action:
  786.  *    EOB_ACT_LAST_MATCH -
  787.  *    EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  788.  *    EOB_ACT_END_OF_FILE - end of file
  789.  */
  790.  
  791. static int yy_get_next_buffer()
  792.     {
  793.     register char *dest = yy_current_buffer->yy_ch_buf;
  794.     register char *source = yytext_ptr;
  795.     register int number_to_move, i;
  796.     int ret_val;
  797.  
  798.     if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  799.         YY_FATAL_ERROR(
  800.         "fatal flex scanner internal error--end of buffer missed" );
  801.  
  802.     if ( yy_current_buffer->yy_fill_buffer == 0 )
  803.         { /* Don't try to fill the buffer, so this is an EOF. */
  804.         if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  805.             {
  806.             /* We matched a single character, the EOB, so
  807.              * treat this as a final EOF.
  808.              */
  809.             return EOB_ACT_END_OF_FILE;
  810.             }
  811.  
  812.         else
  813.             {
  814.             /* We matched some text prior to the EOB, first
  815.              * process it.
  816.              */
  817.             return EOB_ACT_LAST_MATCH;
  818.             }
  819.         }
  820.  
  821.     /* Try to read more data. */
  822.  
  823.     /* First move last chars to start of buffer. */
  824.     number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
  825.  
  826.     for ( i = 0; i < number_to_move; ++i )
  827.         *(dest++) = *(source++);
  828.  
  829.     if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  830.         /* don't do the read, it's not guaranteed to return an EOF,
  831.          * just force an EOF
  832.          */
  833.         yy_current_buffer->yy_n_chars = yy_n_chars = 0;
  834.  
  835.     else
  836.         {
  837.         int num_to_read =
  838.             yy_current_buffer->yy_buf_size - number_to_move - 1;
  839.  
  840.         while ( num_to_read <= 0 )
  841.             { /* Not enough room in the buffer - grow it. */
  842. #ifdef YY_USES_REJECT
  843.             YY_FATAL_ERROR(
  844. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  845. #else
  846.  
  847.             /* just a shorter name for the current buffer */
  848.             YY_BUFFER_STATE b = yy_current_buffer;
  849.  
  850.             int yy_c_buf_p_offset =
  851.                 (int) (yy_c_buf_p - b->yy_ch_buf);
  852.  
  853.             if ( b->yy_is_our_buffer )
  854.                 {
  855.                 int new_size = b->yy_buf_size * 2;
  856.  
  857.                 if ( new_size <= 0 )
  858.                     b->yy_buf_size += b->yy_buf_size / 8;
  859.                 else
  860.                     b->yy_buf_size *= 2;
  861.  
  862.                 b->yy_ch_buf = (char *)
  863.                     /* Include room in for 2 EOB chars. */
  864.                     yy_flex_realloc( (void *) b->yy_ch_buf,
  865.                              b->yy_buf_size + 2 );
  866.                 }
  867.             else
  868.                 /* Can't grow it, we don't own it. */
  869.                 b->yy_ch_buf = 0;
  870.  
  871.             if ( ! b->yy_ch_buf )
  872.                 YY_FATAL_ERROR(
  873.                 "fatal error - scanner input buffer overflow" );
  874.  
  875.             yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  876.  
  877.             num_to_read = yy_current_buffer->yy_buf_size -
  878.                         number_to_move - 1;
  879. #endif
  880.             }
  881.  
  882.         if ( num_to_read > YY_READ_BUF_SIZE )
  883.             num_to_read = YY_READ_BUF_SIZE;
  884.  
  885.         /* Read in more data. */
  886.         YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  887.             yy_n_chars, num_to_read );
  888.  
  889.         yy_current_buffer->yy_n_chars = yy_n_chars;
  890.         }
  891.  
  892.     if ( yy_n_chars == 0 )
  893.         {
  894.         if ( number_to_move == YY_MORE_ADJ )
  895.             {
  896.             ret_val = EOB_ACT_END_OF_FILE;
  897.             yyrestart( yyin );
  898.             }
  899.  
  900.         else
  901.             {
  902.             ret_val = EOB_ACT_LAST_MATCH;
  903.             yy_current_buffer->yy_buffer_status =
  904.                 YY_BUFFER_EOF_PENDING;
  905.             }
  906.         }
  907.  
  908.     else
  909.         ret_val = EOB_ACT_CONTINUE_SCAN;
  910.  
  911.     yy_n_chars += number_to_move;
  912.     yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  913.     yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  914.  
  915.     yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
  916.  
  917.     return ret_val;
  918.     }
  919.  
  920.  
  921. /* yy_get_previous_state - get the state just before the EOB char was reached */
  922.  
  923. static yy_state_type yy_get_previous_state()
  924.     {
  925.     register yy_state_type yy_current_state;
  926.     register char *yy_cp;
  927.  
  928.     yy_current_state = yy_start;
  929.  
  930.     for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  931.         {
  932.         register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  933.         if ( yy_accept[yy_current_state] )
  934.             {
  935.             yy_last_accepting_state = yy_current_state;
  936.             yy_last_accepting_cpos = yy_cp;
  937.             }
  938.         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  939.             {
  940.             yy_current_state = (int) yy_def[yy_current_state];
  941.             if ( yy_current_state >= 20 )
  942.                 yy_c = yy_meta[(unsigned int) yy_c];
  943.             }
  944.         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  945.         }
  946.  
  947.     return yy_current_state;
  948.     }
  949.  
  950.  
  951. /* yy_try_NUL_trans - try to make a transition on the NUL character
  952.  *
  953.  * synopsis
  954.  *    next_state = yy_try_NUL_trans( current_state );
  955.  */
  956.  
  957. #ifdef YY_USE_PROTOS
  958. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  959. #else
  960. static yy_state_type yy_try_NUL_trans( yy_current_state )
  961. yy_state_type yy_current_state;
  962. #endif
  963.     {
  964.     register int yy_is_jam;
  965.     register char *yy_cp = yy_c_buf_p;
  966.  
  967.     register YY_CHAR yy_c = 1;
  968.     if ( yy_accept[yy_current_state] )
  969.         {
  970.         yy_last_accepting_state = yy_current_state;
  971.         yy_last_accepting_cpos = yy_cp;
  972.         }
  973.     while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  974.         {
  975.         yy_current_state = (int) yy_def[yy_current_state];
  976.         if ( yy_current_state >= 20 )
  977.             yy_c = yy_meta[(unsigned int) yy_c];
  978.         }
  979.     yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  980.     yy_is_jam = (yy_current_state == 19);
  981.  
  982.     return yy_is_jam ? 0 : yy_current_state;
  983.     }
  984.  
  985.  
  986. #ifndef YY_NO_UNPUT
  987. #ifdef YY_USE_PROTOS
  988. static void yyunput( int c, register char *yy_bp )
  989. #else
  990. static void yyunput( c, yy_bp )
  991. int c;
  992. register char *yy_bp;
  993. #endif
  994.     {
  995.     register char *yy_cp = yy_c_buf_p;
  996.  
  997.     /* undo effects of setting up yytext */
  998.     *yy_cp = yy_hold_char;
  999.  
  1000.     if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1001.         { /* need to shift things up to make room */
  1002.         /* +2 for EOB chars. */
  1003.         register int number_to_move = yy_n_chars + 2;
  1004.         register char *dest = &yy_current_buffer->yy_ch_buf[
  1005.                     yy_current_buffer->yy_buf_size + 2];
  1006.         register char *source =
  1007.                 &yy_current_buffer->yy_ch_buf[number_to_move];
  1008.  
  1009.         while ( source > yy_current_buffer->yy_ch_buf )
  1010.             *--dest = *--source;
  1011.  
  1012.         yy_cp += (int) (dest - source);
  1013.         yy_bp += (int) (dest - source);
  1014.         yy_current_buffer->yy_n_chars =
  1015.             yy_n_chars = yy_current_buffer->yy_buf_size;
  1016.  
  1017.         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1018.             YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1019.         }
  1020.  
  1021.     *--yy_cp = (char) c;
  1022.  
  1023.  
  1024.     yytext_ptr = yy_bp;
  1025.     yy_hold_char = *yy_cp;
  1026.     yy_c_buf_p = yy_cp;
  1027.     }
  1028. #endif    /* ifndef YY_NO_UNPUT */
  1029.  
  1030.  
  1031. #ifdef __cplusplus
  1032. static int yyinput()
  1033. #else
  1034. static int input()
  1035. #endif
  1036.     {
  1037.     int c;
  1038.  
  1039.     *yy_c_buf_p = yy_hold_char;
  1040.  
  1041.     if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1042.         {
  1043.         /* yy_c_buf_p now points to the character we want to return.
  1044.          * If this occurs *before* the EOB characters, then it's a
  1045.          * valid NUL; if not, then we've hit the end of the buffer.
  1046.          */
  1047.         if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1048.             /* This was really a NUL. */
  1049.             *yy_c_buf_p = '\0';
  1050.  
  1051.         else
  1052.             { /* need more input */
  1053.             int offset = yy_c_buf_p - yytext_ptr;
  1054.             ++yy_c_buf_p;
  1055.  
  1056.             switch ( yy_get_next_buffer() )
  1057.                 {
  1058.                 case EOB_ACT_LAST_MATCH:
  1059.                     /* This happens because yy_g_n_b()
  1060.                      * sees that we've accumulated a
  1061.                      * token and flags that we need to
  1062.                      * try matching the token before
  1063.                      * proceeding.  But for input(),
  1064.                      * there's no matching to consider.
  1065.                      * So convert the EOB_ACT_LAST_MATCH
  1066.                      * to EOB_ACT_END_OF_FILE.
  1067.                      */
  1068.  
  1069.                     /* Reset buffer status. */
  1070.                     yyrestart( yyin );
  1071.  
  1072.                     /* fall through */
  1073.  
  1074.                 case EOB_ACT_END_OF_FILE:
  1075.                     {
  1076.                     if ( yywrap() )
  1077.                         return EOF;
  1078.  
  1079.                     if ( ! yy_did_buffer_switch_on_eof )
  1080.                         YY_NEW_FILE;
  1081. #ifdef __cplusplus
  1082.                     return yyinput();
  1083. #else
  1084.                     return input();
  1085. #endif
  1086.                     }
  1087.  
  1088.                 case EOB_ACT_CONTINUE_SCAN:
  1089.                     yy_c_buf_p = yytext_ptr + offset;
  1090.                     break;
  1091.                 }
  1092.             }
  1093.         }
  1094.  
  1095.     c = *(unsigned char *) yy_c_buf_p;    /* cast for 8-bit char's */
  1096.     *yy_c_buf_p = '\0';    /* preserve yytext */
  1097.     yy_hold_char = *++yy_c_buf_p;
  1098.  
  1099.  
  1100.     return c;
  1101.     }
  1102.  
  1103.  
  1104. #ifdef YY_USE_PROTOS
  1105. void yyrestart( FILE *input_file )
  1106. #else
  1107. void yyrestart( input_file )
  1108. FILE *input_file;
  1109. #endif
  1110.     {
  1111.     if ( ! yy_current_buffer )
  1112.         yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1113.  
  1114.     yy_init_buffer( yy_current_buffer, input_file );
  1115.     yy_load_buffer_state();
  1116.     }
  1117.  
  1118.  
  1119. #ifdef YY_USE_PROTOS
  1120. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1121. #else
  1122. void yy_switch_to_buffer( new_buffer )
  1123. YY_BUFFER_STATE new_buffer;
  1124. #endif
  1125.     {
  1126.     if ( yy_current_buffer == new_buffer )
  1127.         return;
  1128.  
  1129.     if ( yy_current_buffer )
  1130.         {
  1131.         /* Flush out information for old buffer. */
  1132.         *yy_c_buf_p = yy_hold_char;
  1133.         yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1134.         yy_current_buffer->yy_n_chars = yy_n_chars;
  1135.         }
  1136.  
  1137.     yy_current_buffer = new_buffer;
  1138.     yy_load_buffer_state();
  1139.  
  1140.     /* We don't actually know whether we did this switch during
  1141.      * EOF (yywrap()) processing, but the only time this flag
  1142.      * is looked at is after yywrap() is called, so it's safe
  1143.      * to go ahead and always set it.
  1144.      */
  1145.     yy_did_buffer_switch_on_eof = 1;
  1146.     }
  1147.  
  1148.  
  1149. #ifdef YY_USE_PROTOS
  1150. void yy_load_buffer_state( void )
  1151. #else
  1152. void yy_load_buffer_state()
  1153. #endif
  1154.     {
  1155.     yy_n_chars = yy_current_buffer->yy_n_chars;
  1156.     yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1157.     yyin = yy_current_buffer->yy_input_file;
  1158.     yy_hold_char = *yy_c_buf_p;
  1159.     }
  1160.  
  1161.  
  1162. #ifdef YY_USE_PROTOS
  1163. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1164. #else
  1165. YY_BUFFER_STATE yy_create_buffer( file, size )
  1166. FILE *file;
  1167. int size;
  1168. #endif
  1169.     {
  1170.     YY_BUFFER_STATE b;
  1171.  
  1172.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1173.     if ( ! b )
  1174.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1175.  
  1176.     b->yy_buf_size = size;
  1177.  
  1178.     /* yy_ch_buf has to be 2 characters longer than the size given because
  1179.      * we need to put in 2 end-of-buffer characters.
  1180.      */
  1181.     b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1182.     if ( ! b->yy_ch_buf )
  1183.         YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1184.  
  1185.     b->yy_is_our_buffer = 1;
  1186.  
  1187.     yy_init_buffer( b, file );
  1188.  
  1189.     return b;
  1190.     }
  1191.  
  1192.  
  1193. #ifdef YY_USE_PROTOS
  1194. void yy_delete_buffer( YY_BUFFER_STATE b )
  1195. #else
  1196. void yy_delete_buffer( b )
  1197. YY_BUFFER_STATE b;
  1198. #endif
  1199.     {
  1200.     if ( ! b )
  1201.         return;
  1202.  
  1203.     if ( b == yy_current_buffer )
  1204.         yy_current_buffer = (YY_BUFFER_STATE) 0;
  1205.  
  1206.     if ( b->yy_is_our_buffer )
  1207.         yy_flex_free( (void *) b->yy_ch_buf );
  1208.  
  1209.     yy_flex_free( (void *) b );
  1210.     }
  1211.  
  1212.  
  1213. #ifndef YY_ALWAYS_INTERACTIVE
  1214. #ifndef YY_NEVER_INTERACTIVE
  1215. extern int isatty YY_PROTO(( int ));
  1216. #endif
  1217. #endif
  1218.  
  1219. #ifdef YY_USE_PROTOS
  1220. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1221. #else
  1222. void yy_init_buffer( b, file )
  1223. YY_BUFFER_STATE b;
  1224. FILE *file;
  1225. #endif
  1226.  
  1227.  
  1228.     {
  1229.     yy_flush_buffer( b );
  1230.  
  1231.     b->yy_input_file = file;
  1232.     b->yy_fill_buffer = 1;
  1233.  
  1234. #if YY_ALWAYS_INTERACTIVE
  1235.     b->yy_is_interactive = 1;
  1236. #else
  1237. #if YY_NEVER_INTERACTIVE
  1238.     b->yy_is_interactive = 0;
  1239. #else
  1240.     b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
  1241. #endif
  1242. #endif
  1243.     }
  1244.  
  1245.  
  1246. #ifdef YY_USE_PROTOS
  1247. void yy_flush_buffer( YY_BUFFER_STATE b )
  1248. #else
  1249. void yy_flush_buffer( b )
  1250. YY_BUFFER_STATE b;
  1251. #endif
  1252.  
  1253.     {
  1254.     if ( ! b )
  1255.         return;
  1256.  
  1257.     b->yy_n_chars = 0;
  1258.  
  1259.     /* We always need two end-of-buffer characters.  The first causes
  1260.      * a transition to the end-of-buffer state.  The second causes
  1261.      * a jam in that state.
  1262.      */
  1263.     b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1264.     b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1265.  
  1266.     b->yy_buf_pos = &b->yy_ch_buf[0];
  1267.  
  1268.     b->yy_at_bol = 1;
  1269.     b->yy_buffer_status = YY_BUFFER_NEW;
  1270.  
  1271.     if ( b == yy_current_buffer )
  1272.         yy_load_buffer_state();
  1273.     }
  1274.  
  1275.  
  1276. #ifndef YY_NO_SCAN_BUFFER
  1277. #ifdef YY_USE_PROTOS
  1278. YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  1279. #else
  1280. YY_BUFFER_STATE yy_scan_buffer( base, size )
  1281. char *base;
  1282. yy_size_t size;
  1283. #endif
  1284.     {
  1285.     YY_BUFFER_STATE b;
  1286.  
  1287.     if ( size < 2 ||
  1288.          base[size-2] != YY_END_OF_BUFFER_CHAR ||
  1289.          base[size-1] != YY_END_OF_BUFFER_CHAR )
  1290.         /* They forgot to leave room for the EOB's. */
  1291.         return 0;
  1292.  
  1293.     b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1294.     if ( ! b )
  1295.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
  1296.  
  1297.     b->yy_buf_size = size - 2;    /* "- 2" to take care of EOB's */
  1298.     b->yy_buf_pos = b->yy_ch_buf = base;
  1299.     b->yy_is_our_buffer = 0;
  1300.     b->yy_input_file = 0;
  1301.     b->yy_n_chars = b->yy_buf_size;
  1302.     b->yy_is_interactive = 0;
  1303.     b->yy_at_bol = 1;
  1304.     b->yy_fill_buffer = 0;
  1305.     b->yy_buffer_status = YY_BUFFER_NEW;
  1306.  
  1307.     yy_switch_to_buffer( b );
  1308.  
  1309.     return b;
  1310.     }
  1311. #endif
  1312.  
  1313.  
  1314. #ifndef YY_NO_SCAN_STRING
  1315. #ifdef YY_USE_PROTOS
  1316. YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
  1317. #else
  1318. YY_BUFFER_STATE yy_scan_string( yy_str )
  1319. yyconst char *yy_str;
  1320. #endif
  1321.     {
  1322.     int len;
  1323.     for ( len = 0; yy_str[len]; ++len )
  1324.         ;
  1325.  
  1326.     return yy_scan_bytes( yy_str, len );
  1327.     }
  1328. #endif
  1329.  
  1330.  
  1331. #ifndef YY_NO_SCAN_BYTES
  1332. #ifdef YY_USE_PROTOS
  1333. YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
  1334. #else
  1335. YY_BUFFER_STATE yy_scan_bytes( bytes, len )
  1336. yyconst char *bytes;
  1337. int len;
  1338. #endif
  1339.     {
  1340.     YY_BUFFER_STATE b;
  1341.     char *buf;
  1342.     yy_size_t n;
  1343.     int i;
  1344.  
  1345.     /* Get memory for full buffer, including space for trailing EOB's. */
  1346.     n = len + 2;
  1347.     buf = (char *) yy_flex_alloc( n );
  1348.     if ( ! buf )
  1349.         YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
  1350.  
  1351.     for ( i = 0; i < len; ++i )
  1352.         buf[i] = bytes[i];
  1353.  
  1354.     buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
  1355.  
  1356.     b = yy_scan_buffer( buf, n );
  1357.     if ( ! b )
  1358.         YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
  1359.  
  1360.     /* It's okay to grow etc. this buffer, and we should throw it
  1361.      * away when we're done.
  1362.      */
  1363.     b->yy_is_our_buffer = 1;
  1364.  
  1365.     return b;
  1366.     }
  1367. #endif
  1368.  
  1369.  
  1370. #ifndef YY_NO_PUSH_STATE
  1371. #ifdef YY_USE_PROTOS
  1372. static void yy_push_state( int new_state )
  1373. #else
  1374. static void yy_push_state( new_state )
  1375. int new_state;
  1376. #endif
  1377.     {
  1378.     if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1379.         {
  1380.         yy_size_t new_size;
  1381.  
  1382.         yy_start_stack_depth += YY_START_STACK_INCR;
  1383.         new_size = yy_start_stack_depth * sizeof( int );
  1384.  
  1385.         if ( ! yy_start_stack )
  1386.             yy_start_stack = (int *) yy_flex_alloc( new_size );
  1387.  
  1388.         else
  1389.             yy_start_stack = (int *) yy_flex_realloc(
  1390.                     (void *) yy_start_stack, new_size );
  1391.  
  1392.         if ( ! yy_start_stack )
  1393.             YY_FATAL_ERROR(
  1394.             "out of memory expanding start-condition stack" );
  1395.         }
  1396.  
  1397.     yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1398.  
  1399.     BEGIN(new_state);
  1400.     }
  1401. #endif
  1402.  
  1403.  
  1404. #ifndef YY_NO_POP_STATE
  1405. static void yy_pop_state()
  1406.     {
  1407.     if ( --yy_start_stack_ptr < 0 )
  1408.         YY_FATAL_ERROR( "start-condition stack underflow" );
  1409.  
  1410.     BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1411.     }
  1412. #endif
  1413.  
  1414.  
  1415. #ifndef YY_NO_TOP_STATE
  1416. static int yy_top_state()
  1417.     {
  1418.     return yy_start_stack[yy_start_stack_ptr - 1];
  1419.     }
  1420. #endif
  1421.  
  1422. #ifndef YY_EXIT_FAILURE
  1423. #define YY_EXIT_FAILURE 2
  1424. #endif
  1425.  
  1426. #ifdef YY_USE_PROTOS
  1427. static void yy_fatal_error( yyconst char msg[] )
  1428. #else
  1429. static void yy_fatal_error( msg )
  1430. char msg[];
  1431. #endif
  1432.     {
  1433.     (void) fprintf( stderr, "%s\n", msg );
  1434.     exit( YY_EXIT_FAILURE );
  1435.     }
  1436.  
  1437.  
  1438.  
  1439. /* Redefine yyless() so it works in section 3 code. */
  1440.  
  1441. #undef yyless
  1442. #define yyless(n) \
  1443.     do \
  1444.         { \
  1445.         /* Undo effects of setting up yytext. */ \
  1446.         yytext[yyleng] = yy_hold_char; \
  1447.         yy_c_buf_p = yytext + n; \
  1448.         yy_hold_char = *yy_c_buf_p; \
  1449.         *yy_c_buf_p = '\0'; \
  1450.         yyleng = n; \
  1451.         } \
  1452.     while ( 0 )
  1453.  
  1454.  
  1455. /* Internal utility routines. */
  1456.  
  1457. #ifndef yytext_ptr
  1458. #ifdef YY_USE_PROTOS
  1459. static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
  1460. #else
  1461. static void yy_flex_strncpy( s1, s2, n )
  1462. char *s1;
  1463. yyconst char *s2;
  1464. int n;
  1465. #endif
  1466.     {
  1467.     register int i;
  1468.     for ( i = 0; i < n; ++i )
  1469.         s1[i] = s2[i];
  1470.     }
  1471. #endif
  1472.  
  1473. #ifdef YY_NEED_STRLEN
  1474. #ifdef YY_USE_PROTOS
  1475. static int yy_flex_strlen( yyconst char *s )
  1476. #else
  1477. static int yy_flex_strlen( s )
  1478. yyconst char *s;
  1479. #endif
  1480.     {
  1481.     register int n;
  1482.     for ( n = 0; s[n]; ++n )
  1483.         ;
  1484.  
  1485.     return n;
  1486.     }
  1487. #endif
  1488.  
  1489.  
  1490. #ifdef YY_USE_PROTOS
  1491. static void *yy_flex_alloc( yy_size_t size )
  1492. #else
  1493. static void *yy_flex_alloc( size )
  1494. yy_size_t size;
  1495. #endif
  1496.     {
  1497.     return (void *) malloc( size );
  1498.     }
  1499.  
  1500. #ifdef YY_USE_PROTOS
  1501. static void *yy_flex_realloc( void *ptr, yy_size_t size )
  1502. #else
  1503. static void *yy_flex_realloc( ptr, size )
  1504. void *ptr;
  1505. yy_size_t size;
  1506. #endif
  1507.     {
  1508.     /* The cast to (char *) in the following accommodates both
  1509.      * implementations that use char* generic pointers, and those
  1510.      * that use void* generic pointers.  It works with the latter
  1511.      * because both ANSI C and C++ allow castless assignment from
  1512.      * any pointer type to void*, and deal with argument conversions
  1513.      * as though doing an assignment.
  1514.      */
  1515.     return (void *) realloc( (char *) ptr, size );
  1516.     }
  1517.  
  1518. #ifdef YY_USE_PROTOS
  1519. static void yy_flex_free( void *ptr )
  1520. #else
  1521. static void yy_flex_free( ptr )
  1522. void *ptr;
  1523. #endif
  1524.     {
  1525.     free( ptr );
  1526.     }
  1527.  
  1528. #if YY_MAIN
  1529. int main()
  1530.     {
  1531.     yylex();
  1532.     return 0;
  1533.     }
  1534. #endif
  1535. #line 26 "head.l"
  1536.  
  1537.  
  1538. void scanheader(char *file) {
  1539.     FILE *f;
  1540.  
  1541.     actfile=file;
  1542.     lineno=0;
  1543.     if(NULL==(yyin=f=fopen(file,"rb"))) return;
  1544.     yylex();
  1545.     fclose(f);
  1546. }
  1547.  
  1548.